/**
 *  @file BD1.h
 *  @author Criado por Daniel Bittencourt e Davi Viana
 *  @version 14
 *  @date 24/09/08
 *  @brief Este arquivo header contém as definições de todas as estruturas e protótipos das funçÕes utilizadas no trabalho prático 1
 *
 **/

#ifndef BD1
#define BD1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>    // sysconf(3)
#include <math.h>



/**
*Definicao de tamanhos
**/

/**
*Hash
**/
/**
	*	@def blk_size Blocos tem 4096 bytes de tamanho (Padrão Linux)
	*	@def reg_dados Registros tem 110 bytes
	*   @def reg_blk Um bloco pode conter 37 registros -> (4096 / 110) = 37
	*   @def blk_total Numero total de blocos -> (2.000.000 / 37) = 54055
	*   @def blks_bucket Cada Bucket podera ter ate 97 blocos. 97 foi escolhido por ser um número que fará
um bom espalhamento pelo arquivo de dados e por ser primo.
    *   @def num_buckets Como a quantidade total de blocos e 54055 e cada bucket comporta 97 blocos, teremos 558 buckets
	**/


#define blk_size 4096

#define reg_dados 110

#define reg_blk 37

#define blk_total 54055

#define blks_bucket 97

#define num_buckets 558


/**
*Arvore B
**/
/**
*numero total de indices. Um indice por bloco do arquivo de dados
**/
#define num_ind  50000
/**um bloco pode conter no max 2m * 4(chave) + (2m+1)* 4 (apontador p/ int) < = 4096
*   Logo m = 255 e 2m = 510
**/
#define ind_blk 510


/**
*   @typedef tipoDado
*   @brief Descreve o tipo que contém a struct dado para a leitura de dados da linha.
*   @sa @struct dado
*/

/**
	*	@struct dado
	*	@brief Struct que descreve os campos do registro.
	*   É usado para fazer a leitura e divisão dos campos da linha lida do arquivo base.
	*   @param CODIGO Aponta para uma string que contém o Codigo do registro
	*   @param NOME Aponta para uma string que contém o nome da pessoa
	*   @param DATA_NASC Aponta para uma string que contém a data de nascimento
	*   @param LOCAL Aponta para uma string que contém a cidade e estado do regitro
	**/

typedef struct dado{
    char	*CODIGO;
    char    *NOME;
    char	*DATA_NASC;
    char	*LOCAL;
}tipoDado;

/**
*   @typedef tipoDadoHash
*   @brief Descreve o tipo que contém a struct dadoHash que receberá os dados das linhas do arquivo base, no arq. de dados.
*   @sa @struct dadoHash
*/

/**
	*	@struct dadoHash
	*	@brief Struct que descreve os campos do registro a ser gravado no arquivo.
	*   É usado para fazer o armazenamento e divisão dos campos da linha lida do arquivo base no arquivo de dados.
	*   @param CODIGO Armazena o Codigo do registro
	*   @param NOME Armazena o nome da pessoa
	*   @param DATA_NASC Armazena a data de nascimento
	*   @param LOCAL Armazena a cidade e estado do regitro
	**/

typedef struct dadoHash{
    char CODIGO[8];
    char NOME[60];
    char DATA_NASC[10];
    char LOCAL[32];
}tipoDadoHash;

/**
*   @typedef tipoBloco
*   @brief Descreve o tipo que descreve um bloco.
*   @sa @struct bloco
*/

/**
	*	@struct bloco
	*	@brief Struct que descreve um Bloco.
	*   Tipo que auxilia no acesso aos dados em cada bloco. Não ha problema em colocar a variável
	*   regAtual para fazer parte do bloco pois em cada bloco tem-se ainda 26 bytes de sobra.
	*   Como regAtual é um inteiro e ocupa 4 bytes apenas ainda ficam sobrando 22 bytes.
	*   @param regAtual Auxilia a insereção dos dados indicando qual é o registro que atual a ser escrito
	*   @param registros Vetor que armazena os registros no bloco. Seu tamanho é dado por reg_blk
	*   @sa @typedef tipoDadoHash
	**/

typedef struct bloco{
    int regAtual;
    tipoDadoHash registros[reg_blk];
}tipoBloco;

/**
*   @typedef tipoBucket
*   @brief Descreve os tipos de dados que compõem um Bucket.
*   @sa @struct bucket
*/

/**
	*	@struct bucket
	*	@brief Struct que descreve um Bucket.
	*   Tipo que auxilia no acesso aos dados em cada Bucket. fatorUtil e blkAtual tem apenas 4 bytes cada
    *   partindo do principio que eles serão alocados no primeiro boco de cada bucket. Ainda ficarão livres
    *   18 bytes neste primeiro bloco do bucket. O que não atrapalha a leitura do disco por leitura de dados
    *   maiores que 1 bloco.
	*   @param fatorUtil Relação entre quantidade de registros usados e reg. livres (não Usado)
	*   @param blkAtual Diz qual é o bloco que está sendo mexido na hora da escrita de Dados
	*   @param blocos Vetor de elementos do tipo bloco
	*   @sa @typedef tipoBucket
	*   @sa @typedef tipoBloco
	**/

typedef struct bucket{
    int fatorUtil; //Relação entre quantidade de registros usados e
    int blkAtual; //Diz qual é o bloco que está recebendo as alocações atualmente
    tipoBloco blocos[blks_bucket];
}tipoBucket;

#endif
